/*
  作者：不正经绣才
  日期：2025.8.26
*/
const { logInfo, logWarn, logError } = require('../../utils/log.js');
Page({
  data: {
    navHeight: 44, // 导航栏高度
    statusBarHeight: 20, // 状态栏高度
    capsuleButtonInfo: null, // 胶囊按钮信息
    wheelId: null,
    wheelName: '',
    items: [
      { text: '', color: '#ff7675', weight: 1 } // 修改默认颜色为colorOptions数组中的第一个颜色
    ],
    isEdit: false,
    colorOptions: [
      '#ff7675',
      '#74b9ff',
      '#55efc4',
      '#ffeaa7',
      '#a29bfe',
      '#fd79a8',
      '#fdcb6e',
      '#00cec9',
    ],
    colorNames: [
      '珊瑚红',
      '天空蓝',
      '薄荷绿',
      '柠檬黄',
      '淡紫',
      '蔷薇粉',
      '琥珀黄',
      '青绿色',
    ],
    colorIndex: [0],
    // 删除了 batchInput, showBatchModal, batchItemCount 相关数据
    nextColorIndex: 1, // 修改：记录下一个要使用的颜色索引（初始为1，因为第一个项目已使用索引0）
  },

  onLoad(options) {
    if (options.id) {
      // 编辑现有转盘
      this.loadWheelData(options.id);
      this.setData({ isEdit: true });
    }
  },

  // 处理导航栏高度变化事件
  onNavHeightChange: function(e) {
    const navHeight = e.detail.navHeight;
    const statusBarHeight = e.detail.statusBarHeight;
    const capsuleButtonInfo = e.detail.capsuleButtonInfo;
    
    this.setData({
      navHeight: navHeight,
      statusBarHeight: statusBarHeight,
      capsuleButtonInfo: capsuleButtonInfo
    });
  },

  // 加载转盘数据
  loadWheelData(id) {
    try {
      const wheels = wx.getStorageSync('wheels') || [];
      const wheel = wheels.find(w => w.id === id);
      
      if (wheel) {
        // 计算颜色索引
        const colorIndex = wheel.items.map(item => {
          const index = this.data.colorOptions.indexOf(item.color);
          return index !== -1 ? index : 0;
        });
  
        // 关键：计算编辑时的nextColorIndex（基于最后一个项目的颜色索引）
        let nextColorIndex = 0;
        if (wheel.items.length > 0) {
          // 找到最后一个项目的颜色在colorOptions中的索引
          const lastColor = wheel.items[wheel.items.length - 1].color;
          const lastColorIdx = this.data.colorOptions.indexOf(lastColor);
          // 下一个索引 = 最后一个索引 + 1（循环）
          nextColorIndex = (lastColorIdx + 1) % this.data.colorOptions.length;
        }
        
        this.setData({
          wheelId: id,
          wheelName: wheel.name,
          items: wheel.items,
          colorIndex,
          nextColorIndex: nextColorIndex // 编辑时初始化索引
        });
      }
    } catch (e) {
      logError('加载转盘数据失败', e);
    }
  },

  // 添加项目
  addItem() {
    const { items, colorIndex, colorOptions, nextColorIndex } = this.data;
    
    // 检查是否超过最大项目数量限制（20个）
    if (items.length >= 20) {
      wx.showToast({
        title: '最多只能添加20个项目',
        icon: 'none'
      });
      return;
    }
    
    // 1. 按当前索引取颜色（从colorOptions中获取）
    const currentColor = colorOptions[nextColorIndex];
    
    // 2. 添加新项目（使用当前颜色，权重默认1）
    items.push({ text: '', color: currentColor, weight: 1 });
    
    // 3. 颜色索引数组同步添加当前索引（用于下拉选择时默认选中）
    colorIndex.push(nextColorIndex);
    
    // 4. 更新"下一个颜色索引"：+1，若超过colorOptions长度则重置为0（循环）
    const newNextColorIndex = (nextColorIndex + 1) % colorOptions.length;
    
    // 5. 同步更新数据
    this.setData({ 
      items, 
      colorIndex, 
      nextColorIndex: newNextColorIndex // 保存下次要用的索引
    });
  },

  // 删除了 onBatchInputChange 方法

  // 删除项目
  removeItem(e) {
    const index = e.currentTarget.dataset.index;
    const items = this.data.items;
    const colorIndex = this.data.colorIndex;
    
    if (items.length > 1) {
      items.splice(index, 1);
      colorIndex.splice(index, 1);
      this.setData({ items, colorIndex });
    } else {
      wx.showToast({
        title: '至少保留一个项目',
        icon: 'none'
      });
    }
  },

  // 输入项目文本
  onItemTextInput(e) {
    const index = e.currentTarget.dataset.index;
    const value = e.detail.value;
    const items = this.data.items;
    
    // 限制项目名称最长为10个字
    if (value.length > 10) {
      wx.showToast({
        title: '项目名称不能超过10个字',
        icon: 'none'
      });
      return;
    }
    
    items[index].text = value;
    this.setData({ items });
  },

  // 输入项目权重
  onItemWeightInput(e) {
    const index = e.currentTarget.dataset.index;
    // 直接获取输入值，不强制转为整数，保留原始输入
    const value = e.detail.value.trim();
    const items = this.data.items;

    if (value === '') {
      // 输入为空时暂时保持空值（失焦时会处理为1）
      items[index].weight = '';
    } else {
      // 将输入值转为数字，如果转换失败则使用1
      const num = Number(value);
      items[index].weight = isNaN(num) ? 1 : num;
    }

    this.setData({ items });
  },

  // 新增：在输入框失焦时确保权重合法
  onItemWeightBlur(e) {
    const index = e.currentTarget.dataset.index;
    const value = e.detail.value.trim();
    const items = this.data.items;

    // 失焦时如果为空或无效，设置为1
    if (value === '' || isNaN(Number(value))) {
      items[index].weight = 1;
    } else {
    	// 确保是数字且不小于1
    	items[index].weight = Math.max(1, Number(value));
    }

    this.setData({ items });
  },

  // 选择颜色
  onColorChange(e) {
    const index = e.currentTarget.dataset.index;
    const selectedIdx = e.detail.value; // 选中的中文名称在 colorNames 中的索引
    
    // 关键：通过索引从 colorCodes 中获取实际颜色代码
    const selectedColor = this.data.colorOptions[selectedIdx]; 
    
    // 更新当前项目的颜色（存储的是颜色代码，而非中文名称）
    const colorIndex = [...this.data.colorIndex];
    const items = [...this.data.items];
    colorIndex[index] = selectedIdx; // 保存索引（用于下次默认选中）
    items[index].color = selectedColor; // 保存实际颜色代码（用于渲染）
    
    this.setData({ colorIndex, items });
  },

  // 输入转盘名称
  onNameInput(e) {
    const value = e.detail.value;
    // 限制转盘名称最长为15个字
    if (value.length > 15) {
      wx.showToast({
        title: '转盘名称不能超过15个字',
        icon: 'none'
      });
      return;
    }
    this.setData({ wheelName: value });
  },

  // 保存转盘
  saveWheel() {
    const { wheelName, items, wheelId, isEdit } = this.data;
    const app = getApp(); // 获取全局实例
    
    if (!wheelName.trim()) {
      wx.showToast({
        title: '请输入转盘名称',
        icon: 'none'
      });
      return;
    }
    
    // 检查转盘名称长度
    if (wheelName.trim().length > 15) {
      wx.showToast({
        title: '转盘名称不能超过15个字',
        icon: 'none'
      });
      return;
    }
    
    for (let i = 0; i < items.length; i++) {
      if (!items[i].text.trim()) {
        wx.showToast({
          title: `请输入第${i + 1}个项目名称`,
          icon: 'none'
        });
        return;
      }
      
      // 检查项目名称长度
      if (items[i].text.trim().length > 10) {
        wx.showToast({
          title: `第${i + 1}个项目名称不能超过10个字`,
          icon: 'none'
        });
        return;
      }
    }
    
    try {
      const wheels = wx.getStorageSync('wheels') || [];
      
      // 检查是否超过最大转盘数量限制（20个）
      if (!isEdit && wheels.length >= 20) {
        wx.showToast({
          title: '最多只能创建20个转盘',
          icon: 'none'
        });
        return;
      }
      
      // 检查转盘名称是否已存在（排除当前编辑的转盘）
      const existingWheel = wheels.find(w => w.name === wheelName.trim() && w.id !== wheelId);
      if (existingWheel) {
        wx.showToast({
          title: '该转盘名称已存在',
          icon: 'none'
        });
        return;
      }
      
      const newWheel = {
        id: wheelId || Date.now().toString(),
        name: wheelName,
        items: items.filter(item => item.text.trim())
      };
      
      if (wheelId) {
        // 更新现有转盘
        const index = wheels.findIndex(w => w.id === wheelId);
        if (index !== -1) {
          wheels[index] = newWheel;
        }
      } else {
        // 添加新转盘
        wheels.push(newWheel);
      }
      
      wx.setStorageSync('wheels', wheels);
      // 更新全局变量 allWheels
      app.globalData.allWheels = wheels;
      
      wx.showToast({
        title: '保存成功',
        icon: 'success',
        success: () => {
          // 更新全局当前转盘数据
          app.globalData.currentWheel = newWheel;
          // 更新全局allWheels数据
          app.globalData.allWheels = wheels;
          // 更新本地存储的最后使用转盘ID
          wx.setStorageSync('lastUsedWheelId', newWheel.id);
          // 延迟返回，确保数据保存完成
          setTimeout(() => {
            wx.navigateBack();
          }, 500);
        }
      });
    } catch (e) {
      logError('保存转盘失败', e);
      wx.showToast({
        title: '保存失败',
        icon: 'none'
      });
    }
  },

  backEditPage() {
    wx.navigateBack();
  },
  
  // 配置分享给好友
  onShareAppMessage() {
    return {
      title: '小幸运转盘',
      path: '/pages/edit-wheel/edit-wheel',
      imageUrl: '',
      success: (res) => {
        wx.showToast({
          title: '分享成功',
          icon: 'success',
          duration: 1000
        });
      },
      fail: (res) => {
        wx.showToast({
          title: '分享失败',
          icon: 'none',
          duration: 1000
        });
      }
    }
  },
  
  // 配置分享到朋友圈
  onShareTimeline() {
    return {
      title: '小幸运转盘',
      query: 'page=edit-wheel',
      imageUrl: ''
    }
  }
});